package com.example.juc.JUCsuperior;

import java.util.concurrent.*;

public class demo01 {


    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        这段Java代码的含义是创建一个线程池（Executor），并指定任务执行的方式。实现原理是使用了Java的Executors类中的newSingleThreadExecutor方法。
//
//        原理： Runnable::run是一个方法引用，它表示使用Runnable接口的run方法作为线程任务。这里使用Runnable::run作为参数，这意味着线程池将执行任务run方法。
//
//        用途： newSingleThreadExecutor方法创建了一个只有一个线程的线程池，这对于需要在主线程中频繁地提交任务的情况非常有用，因为它可以确保任务的执行顺序。
//
//        注意事项：
//
//        线程池的大小：newSingleThreadExecutor创建了一个只有一个线程的线程池，这可能不是最佳选择，因为它会阻塞其他待定的任务。在多线程环境下，通常建议使用至少两个线程的线程池，以便于更好地balance任务。
//        异常处理：线程池中的任务可能会抛出异常，但这些异常不会自动传播到主线程。因此，你需要确保在适当的地方处理这些异常，或者使用try-catch语句捕获异常。
//        资源关闭：线程池在使用完毕后需要关闭，以释放资源。在不再使用线程池时，调用shutdown()方法关闭线程池。为了避免忘记关闭线程池，可以使用try-with-resources语句来自动关闭资源。
        Executor executor = Runnable::run; // 创建一个线程池，并指定任务执行的方式
//        Executor executor1 = Runnable::run; // 创建一个线程池，并指定任务执行的方式
        Executor executor2 = Executors.newFixedThreadPool(3); // 创建一个线程池，并指定任务执行的方式
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(
                () -> {
                    System.out.println(Thread.currentThread().getName() + "异步任务1");
                }, executor);

        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "异步任务2");
            return 1;
        }, executor2);
        Integer integer = integerCompletableFuture.get();
        System.out.println(integer);
        System.out.println(completableFuture.get());

    }

}

class CompletableFutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {


        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "----come in CompletableFuture");

            int result = ThreadLocalRandom.current().nextInt();

            System.out.println(Thread.currentThread().getName() + "异步任务");
            return result;
        });
        System.out.println(future.get());
    }
}

class CompletableFutureDemo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {


        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                    System.out.println(Thread.currentThread().getName() + "----come in CompletableFuture");

                    int result = ThreadLocalRandom.current().nextInt();
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "异步任务");


                    return result;
                }).whenComplete((v, e) -> {
                    System.out.println("异步任务完成了");
                })
                .exceptionally(e -> {
                    System.out.println("异步任务异常了");
                    return null;
                });


        System.out.println(Thread.currentThread().getName() + "-----main go on ...");


    }
}

class CompletableFutureDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {


        Executor executor = Executors.newFixedThreadPool(10);


        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                            System.out.println(Thread.currentThread().getName() + "----come in CompletableFuture");

                            int result = ThreadLocalRandom.current().nextInt();
                            try {
                                TimeUnit.SECONDS.sleep(1);
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            System.out.println(Thread.currentThread().getName() + "异步任务");


                            return result;
                        }
                        , executor).whenComplete((v, e) -> {
                    System.out.println("异步任务完成了");
                })
                .exceptionally(e -> {
                    System.out.println("异步任务异常了");
                    return null;
                });

        System.out.println(Thread.currentThread().getName() + "-----main go on ...");

    }
}

class CompletableFutureDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {


        Executor executor = new ThreadPoolExecutor
                (2, 5, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3));


        try {
            CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                                System.out.println(Thread.currentThread().getName() + "----come in CompletableFuture");

                                int result = ThreadLocalRandom.current().nextInt();
                                try {
                                    TimeUnit.SECONDS.sleep(1);
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                                System.out.println(Thread.currentThread().getName() + "异步任务");

                                return result;
                            }
                            , executor).whenComplete((v, e) -> {
                        System.out.println("异步任务完成了");
                    })
                    .exceptionally(e -> {
                        System.out.println("异步任务异常了");
                        return null;
                    });
            System.out.println(Thread.currentThread().getName() + "-----main go on ...");
//            System.out.println(future.get());
        } catch (Exception e) {
        } finally {
            ((ThreadPoolExecutor) executor).shutdownNow();
        }
    }
}
